{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "5.BurgersEquation.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "Y61YA90-WIZ1",
        "i0j73GoH86-m"
      ],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jdtoscano94/Learning-PINNs-in-Pytorch-Physics-Informed-Machine-Learning/blob/main/5_BurgersEquation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Libraries"
      ],
      "metadata": {
        "id": "Y61YA90-WIZ1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " ! pip install pyDOE #Latin Hypercube Sampling"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WZrPCr9GWEAJ",
        "outputId": "1125c4ad-acd0-447e-dbf0-96479450eb2e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: pyDOE in /usr/local/lib/python3.7/dist-packages (0.3.8)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.21.6)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.4.1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.autograd as autograd         # computation graph\n",
        "from torch import Tensor                  # tensor node in the computation graph\n",
        "import torch.nn as nn                     # neural networks\n",
        "import torch.optim as optim               # optimizers e.g. gradient descent, ADAM, etc.\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.gridspec as gridspec\n",
        "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import matplotlib.ticker\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import numpy as np\n",
        "import time\n",
        "from pyDOE import lhs         #Latin Hypercube Sampling\n",
        "import scipy.io\n",
        "\n",
        "#Set default dtype to float32\n",
        "torch.set_default_dtype(torch.float)\n",
        "\n",
        "#PyTorch random number generator\n",
        "torch.manual_seed(1234)\n",
        "\n",
        "# Random number generators in other libraries\n",
        "np.random.seed(1234)\n",
        "\n",
        "# Device configuration\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "print(device)\n",
        "\n",
        "if device == 'cuda': \n",
        "    print(torch.cuda.get_device_name()) \n"
      ],
      "metadata": {
        "id": "OdYMzuSDi7Js",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5afa768f-e286-4609-8cad-0edd4a6554f0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tunning Parameters"
      ],
      "metadata": {
        "id": "UoqCzgLSp61M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "steps=10000\n",
        "lr=1e-1\n",
        "layers = np.array([2,20,20,20,20,20,20,20,20,1]) #8 hidden layers\n",
        "#Nu: Number of training points # Nf: Number of collocation points (Evaluate PDE)\n",
        "N_u = 100 #Total number of data points for 'u'\n",
        "N_f = 10_000 #Total number of collocation points \n",
        "nu = 0.01/np.pi #diffusion coeficient"
      ],
      "metadata": {
        "id": "L2r-CxAnp5Ub"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Auxiliary Functions\n"
      ],
      "metadata": {
        "id": "i0j73GoH86-m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot3D(x,t,y):\n",
        "  x_plot =x.squeeze(1) \n",
        "  t_plot =t.squeeze(1)\n",
        "  X,T= torch.meshgrid(x_plot,t_plot)\n",
        "  F_xt = y\n",
        "  fig,ax=plt.subplots(1,1)\n",
        "  cp = ax.contourf(T,X, F_xt,20,cmap=\"rainbow\")\n",
        "  fig.colorbar(cp) # Add a colorbar to a plot\n",
        "  ax.set_title('F(x,t)')\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  plt.show()\n",
        "  ax = plt.axes(projection='3d')\n",
        "  ax.plot_surface(T.numpy(), X.numpy(), F_xt.numpy(),cmap=\"rainbow\")\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  ax.set_zlabel('f(x,t)')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "F8Y6q7m288zJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot3D_Matrix(x,t,y):\n",
        "  X,T= x,t\n",
        "  F_xt = y\n",
        "  fig,ax=plt.subplots(1,1)\n",
        "  cp = ax.contourf(T,X, F_xt,20,cmap=\"rainbow\")\n",
        "  fig.colorbar(cp) # Add a colorbar to a plot\n",
        "  ax.set_title('F(x,t)')\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  plt.show()\n",
        "  ax = plt.axes(projection='3d')\n",
        "  ax.plot_surface(T.numpy(), X.numpy(), F_xt.numpy(),cmap=\"rainbow\")\n",
        "  ax.set_xlabel('t')\n",
        "  ax.set_ylabel('x')\n",
        "  ax.set_zlabel('f(x,t)')\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "pFS1eS92dhuX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def solutionplot(u_pred,X_u_train,u_train):\n",
        "  #https://github.com/omniscientoctopus/Physics-Informed-Neural-Networks\n",
        "    \n",
        "    fig, ax = plt.subplots()\n",
        "    ax.axis('off')\n",
        "\n",
        "    gs0 = gridspec.GridSpec(1, 2)\n",
        "    gs0.update(top=1-0.06, bottom=1-1/3, left=0.15, right=0.85, wspace=0)\n",
        "    ax = plt.subplot(gs0[:, :])\n",
        "\n",
        "    h = ax.imshow(u_pred, interpolation='nearest', cmap='rainbow', \n",
        "                extent=[T.min(), T.max(), X.min(), X.max()], \n",
        "                origin='lower', aspect='auto')\n",
        "    divider = make_axes_locatable(ax)\n",
        "    cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
        "    fig.colorbar(h, cax=cax)\n",
        "    \n",
        "    ax.plot(X_u_train[:,1], X_u_train[:,0], 'kx', label = 'Data (%d points)' % (u_train.shape[0]), markersize = 4, clip_on = False)\n",
        "\n",
        "    line = np.linspace(x.min(), x.max(), 2)[:,None]\n",
        "    ax.plot(t[25]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
        "    ax.plot(t[50]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
        "    ax.plot(t[75]*np.ones((2,1)), line, 'w-', linewidth = 1)    \n",
        "\n",
        "    ax.set_xlabel('$t$')\n",
        "    ax.set_ylabel('$x$')\n",
        "    ax.legend(frameon=False, loc = 'best')\n",
        "    ax.set_title('$u(x,t)$', fontsize = 10)\n",
        "    \n",
        "    ''' \n",
        "    Slices of the solution at points t = 0.25, t = 0.50 and t = 0.75\n",
        "    '''\n",
        "    \n",
        "    ####### Row 1: u(t,x) slices ##################\n",
        "    gs1 = gridspec.GridSpec(1, 3)\n",
        "    gs1.update(top=1-1/3, bottom=0, left=0.1, right=0.9, wspace=0.5)\n",
        "\n",
        "    ax = plt.subplot(gs1[0, 0])\n",
        "    ax.plot(x,usol.T[25,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "    ax.plot(x,u_pred.T[25,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "    ax.set_xlabel('$x$')\n",
        "    ax.set_ylabel('$u(x,t)$')    \n",
        "    ax.set_title('$t = 0.25s$', fontsize = 10)\n",
        "    ax.axis('square')\n",
        "    ax.set_xlim([-1.1,1.1])\n",
        "    ax.set_ylim([-1.1,1.1])\n",
        "\n",
        "    ax = plt.subplot(gs1[0, 1])\n",
        "    ax.plot(x,usol.T[50,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "    ax.plot(x,u_pred.T[50,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "    ax.set_xlabel('$x$')\n",
        "    ax.set_ylabel('$u(x,t)$')\n",
        "    ax.axis('square')\n",
        "    ax.set_xlim([-1.1,1.1])\n",
        "    ax.set_ylim([-1.1,1.1])\n",
        "    ax.set_title('$t = 0.50s$', fontsize = 10)\n",
        "    ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.35), ncol=5, frameon=False)\n",
        "\n",
        "    ax = plt.subplot(gs1[0, 2])\n",
        "    ax.plot(x,usol.T[75,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "    ax.plot(x,u_pred.T[75,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "    ax.set_xlabel('$x$')\n",
        "    ax.set_ylabel('$u(x,t)$')\n",
        "    ax.axis('square')\n",
        "    ax.set_xlim([-1.1,1.1])\n",
        "    ax.set_ylim([-1.1,1.1])    \n",
        "    ax.set_title('$t = 0.75s$', fontsize = 10)\n",
        "    \n",
        "    plt.savefig('Burgers.png',dpi = 500)   "
      ],
      "metadata": {
        "id": "j7m02X_26hFk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problem Setup\n",
        "https://github.com/omniscientoctopus/Physics-Informed-Neural-Networks\n",
        "\n",
        "**Burgers' Equation**\n",
        "\n",
        "$$\\frac{\\partial u}{\\partial t}+ u\\frac{\\partial u}{\\partial x}=\\nu\\frac{\\partial^2 u}{\\partial x^2} $$\n",
        "\n",
        "$$x\\in[-1,1]$$\n",
        "$$t\\in[0,1]$$\n",
        "\n",
        "## Initial and Boundary Conditions:\n",
        "\n",
        "Given as a matrix (We will extract them from the reference solution) "
      ],
      "metadata": {
        "id": "koofMp-5Y-UA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analysis:\n",
        "## PDE\n",
        "\n",
        "Let:\n",
        "\n",
        "$u_t=\\frac{\\partial u}{\\partial t}$\n",
        "\n",
        "$u_x=\\frac{\\partial u}{\\partial x}$\n",
        "\n",
        "$u_{xx}=\\frac{\\partial^2 u}{\\partial x^2}$\n",
        "\n",
        "So:\n",
        "\n",
        "$$u_t+u(u_x)=\\nu u_{xx}$$\n",
        "\n",
        "If we rearrange our PDE, we get:\n",
        "\n",
        "$$u_t+u(u_x)-\\nu u_{xx}=0$$\n",
        "\n",
        "## Neural Network\n",
        "\n",
        "A Neural Network is a function (See:https://book.sciml.ai/notes/03/):\n",
        "\n",
        "$$NN(X)=W_n\\sigma_{n-1}(W_{n-1}\\sigma_{n-2}(...(W_2(W_1X+b_1)+b_2)+..)+b_{n-1})+b_n$$\n",
        "\n",
        "**Note:**We usually train our NN by iteratively minimizing a loss function ($MSE$:mean squared error) in the training dataset(known data).\n",
        " \n",
        "## PINNs=Neural Network + PDE \n",
        "(See: https://www.sciencedirect.com/science/article/pii/S0021999118307125)\n",
        "\n",
        "We can use a neural network to approximate any function (Universal APproximation Theorem): (See:https://book.sciml.ai/notes/03/)\n",
        "$$NN(x,t)\\approx u(x,t)$$ \n",
        "\n",
        "Since NN is a function, we can obtain its derivatives: $\\frac{\\partial NN}{\\partial t},\\frac{\\partial^2 NN}{\\partial x^2}$.(Automatic Diferentiation) \n",
        "\n",
        "Assume:$$NN(t,x)\\approx u(t,x)$$ \n",
        "\n",
        "Then:\n",
        "\n",
        "$$\\frac{\\partial NN}{\\partial t}+N(\\frac{\\partial NN}{\\partial x})-\\nu\\frac{\\partial^2 NN}{\\partial x^2}\\approx u_t+u(u_x)-\\nu u_{xx}=0$$\n",
        "\n",
        "And:\n",
        "\n",
        "$$\\frac{\\partial NN}{\\partial t}+N(\\frac{\\partial NN}{\\partial x})-\\nu\\frac{\\partial^2 NN}{\\partial x^2}\\approx 0$$\n",
        "\n",
        "\n",
        "We define this function as $f$:\n",
        "\n",
        "$$f(t,x)=\\frac{\\partial NN}{\\partial t}+N(\\frac{\\partial NN}{\\partial x})-\\nu\\frac{\\partial^2 NN}{\\partial x^2}$$\n",
        "\n",
        "If $f\\rightarrow 0$ then our NN would be respecting the physical law.\n",
        "\n",
        "### PINNs' Loss function\n",
        "\n",
        "We evaluate our PDE in a certain number of \"collocation points\" ($N_f$) inside our domain $(x,t)$. Then we iteratively minimize a loss function related to $f$:\n",
        "\n",
        "$$MSE_f=\\frac{1}{N_f}\\sum^{N_f}_{i=1}|f(t_f^i,x_f^i)|^2$$\n",
        "\n",
        "Usually, the training data set is a set of points from which we know the answer. In our case, we will use our boundary(BC) and initial conditions(IC).\n",
        "\n",
        "Since we know the outcome, we select $N_u$ points from our BC and IC and used them to train our network.\n",
        "\n",
        "$$MSE_{u}=\\frac{1}{N_u}\\sum^{N_u}_{i=1}|y(t_{u}^i,x_u^i)-NN(t_{u}^i,x_u^i)|^2$$\n",
        "\n",
        "\n",
        "#### Total Loss:\n",
        "\n",
        "$$MSE=MSE_{u}+MSE_f$$"
      ],
      "metadata": {
        "id": "XYwWBwmbp3S6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Neural Network"
      ],
      "metadata": {
        "id": "ZHYqtyYJs3Jv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FCN(nn.Module):\n",
        "    \n",
        "    def __init__(self,layers):\n",
        "        super().__init__() #call __init__ from parent class \n",
        "              \n",
        "        'activation function'\n",
        "        self.activation = nn.Tanh()\n",
        "\n",
        "        'loss function'\n",
        "        self.loss_function = nn.MSELoss(reduction ='mean')\n",
        "    \n",
        "        'Initialise neural network as a list using nn.Modulelist'  \n",
        "        self.linears = nn.ModuleList([nn.Linear(layers[i], layers[i+1]) for i in range(len(layers)-1)])\n",
        "        \n",
        "        self.iter = 0\n",
        "    \n",
        "        'Xavier Normal Initialization'\n",
        "        for i in range(len(layers)-1):\n",
        "            \n",
        "            nn.init.xavier_normal_(self.linears[i].weight.data, gain=1.0)\n",
        "            \n",
        "            # set biases to zero\n",
        "            nn.init.zeros_(self.linears[i].bias.data)\n",
        "            \n",
        "    'foward pass'\n",
        "    def forward(self,x):\n",
        "        \n",
        "        if torch.is_tensor(x) != True:         \n",
        "            x = torch.from_numpy(x)                \n",
        "        \n",
        "        u_b = torch.from_numpy(ub).float().to(device)\n",
        "        l_b = torch.from_numpy(lb).float().to(device)\n",
        "                      \n",
        "        #preprocessing input \n",
        "        x = (x - l_b)/(u_b - l_b) #feature scaling\n",
        "        \n",
        "        #convert to float\n",
        "        a = x.float()\n",
        "        \n",
        "        for i in range(len(layers)-2):\n",
        "            \n",
        "            z = self.linears[i](a)\n",
        "                        \n",
        "            a = self.activation(z)\n",
        "            \n",
        "        a = self.linears[-1](a)\n",
        "        \n",
        "        return a\n",
        "                        \n",
        "    def loss_BC(self,x,y):\n",
        "                \n",
        "        loss_u = self.loss_function(self.forward(x), y)\n",
        "                \n",
        "        return loss_u\n",
        "    \n",
        "    def loss_PDE(self, X_train_Nf):\n",
        "                        \n",
        "        g = X_train_Nf.clone()\n",
        "                        \n",
        "        g.requires_grad = True\n",
        "        \n",
        "        u = self.forward(g)\n",
        "                \n",
        "        u_x_t = autograd.grad(u,g,torch.ones([X_train_Nf.shape[0], 1]).to(device), retain_graph=True, create_graph=True)[0]\n",
        "                                \n",
        "        u_xx_tt = autograd.grad(u_x_t,g,torch.ones(X_train_Nf.shape).to(device), create_graph=True)[0]\n",
        "                                                            \n",
        "        u_x = u_x_t[:,[0]]\n",
        "        \n",
        "        u_t = u_x_t[:,[1]]\n",
        "        \n",
        "        u_xx = u_xx_tt[:,[0]]\n",
        "                                        \n",
        "        f = u_t + (self.forward(g))*(u_x) - (nu)*u_xx \n",
        "        \n",
        "        loss_f = self.loss_function(f,f_hat)\n",
        "                \n",
        "        return loss_f\n",
        "    \n",
        "    def loss(self,x,y,X_train_Nf):\n",
        "\n",
        "        loss_u = self.loss_BC(x,y)\n",
        "        loss_f = self.loss_PDE(X_train_Nf)\n",
        "        \n",
        "        loss_val = loss_u + loss_f\n",
        "        \n",
        "        return loss_val\n",
        "     \n",
        "    'callable for optimizer'                                       \n",
        "    def closure(self):\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        loss = self.loss(X_train_Nu, U_train_Nu, X_train_Nf)\n",
        "        \n",
        "        loss.backward()\n",
        "                \n",
        "        self.iter += 1\n",
        "        \n",
        "        if self.iter % 100 == 0:\n",
        "\n",
        "            error_vec, _ = PINN.test()\n",
        "        \n",
        "            print(loss,error_vec)\n",
        "\n",
        "        return loss        \n",
        "    \n",
        "    'test neural network'\n",
        "    def test(self):\n",
        "                \n",
        "        u_pred = self.forward(X_test)\n",
        "        \n",
        "        error_vec = torch.linalg.norm((u-u_pred),2)/torch.linalg.norm(u,2)        # Relative L2 Norm of the error (Vector)\n",
        "        \n",
        "        u_pred = u_pred.cpu().detach().numpy()\n",
        "        \n",
        "        u_pred = np.reshape(u_pred,(256,100),order='F')\n",
        "                \n",
        "        return error_vec, u_pred"
      ],
      "metadata": {
        "id": "7EZjlbVMi8w0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Generate data"
      ],
      "metadata": {
        "id": "pOe9yRvxjakj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = scipy.io.loadmat('/content/gdrive/MyDrive/ScientificML/Codes/Learning/Data/Burgers.mat') \n",
        "x = data['x']                                   # 256 points between -1 and 1 [256x1]\n",
        "t = data['t']                                   # 100 time points between 0 and 1 [100x1] \n",
        "usol = data['usol']                             # solution of 256x100 grid points\n",
        "\n",
        "X, T = np.meshgrid(x,t)                         # makes 2 arrays X and T such that u(X[i],T[j])=usol[i][j] are a tuple\n",
        "plot3D(torch.from_numpy(x),torch.from_numpy(t),torch.from_numpy(usol)) #f_real was defined previously(function)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 582
        },
        "id": "go0WGbdx7bXB",
        "outputId": "43747ec0-1f96-443d-d7e6-f593b868fb85"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/functional.py:568: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at  ../aten/src/ATen/native/TensorShape.cpp:2228.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape,t.shape,usol.shape)\n",
        "print(X.shape,T.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gRKvROqlK8_i",
        "outputId": "5c1e39dc-c3d5-4b0a-ead9-3c7cbaf837d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(256, 1) (100, 1) (256, 100)\n",
            "(100, 256) (100, 256)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prepare Data"
      ],
      "metadata": {
        "id": "U66GsxSutJcB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_test = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
        "\n",
        "# Domain bounds\n",
        "lb = X_test[0]  # [-1. 0.]\n",
        "ub = X_test[-1] # [1.  0.99]\n",
        "u_true = usol.flatten('F')[:,None] #Fortran style (Column Major)"
      ],
      "metadata": {
        "id": "1ZN_Jc-gtR-q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(lb,ub)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rrx8VgLR2AYK",
        "outputId": "6b7778a1-ba48-4e44-c040-892a62b9ee9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-1.  0.] [1.   0.99]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training Data"
      ],
      "metadata": {
        "id": "dQxdtgBtsqJj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''Boundary Conditions'''\n",
        "\n",
        "#Initial Condition -1 =< x =<1 and t = 0  \n",
        "left_X = np.hstack((X[0,:][:,None], T[0,:][:,None])) #L1\n",
        "left_U = usol[:,0][:,None]\n",
        "\n",
        "#Boundary Condition x = -1 and 0 =< t =<1\n",
        "bottom_X = np.hstack((X[:,0][:,None], T[:,0][:,None])) #L2\n",
        "bottom_U = usol[-1,:][:,None]\n",
        "\n",
        "#Boundary Condition x = 1 and 0 =< t =<1\n",
        "top_X = np.hstack((X[:,-1][:,None], T[:,0][:,None])) #L3\n",
        "top_U = usol[0,:][:,None]\n",
        "\n",
        "X_train = np.vstack([left_X, bottom_X, top_X]) \n",
        "U_train = np.vstack([left_U, bottom_U, top_U]) \n",
        "\n",
        "#choose random N_u points for training\n",
        "idx = np.random.choice(X_train.shape[0], N_u, replace=False) \n",
        "\n",
        "X_train_Nu = X_train[idx, :] #choose indices from  set 'idx' (x,t)\n",
        "U_train_Nu = U_train[idx,:]      #choose corresponding u\n",
        "\n",
        "'''Collocation Points'''\n",
        "\n",
        "# Latin Hypercube sampling for collocation points \n",
        "# N_f sets of tuples(x,t)\n",
        "X_train_Nf = lb + (ub-lb)*lhs(2,N_f) \n",
        "X_train_Nf = np.vstack((X_train_Nf, X_train_Nu)) # append training points to collocation points "
      ],
      "metadata": {
        "id": "KjFW76MDzRXP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Original shapes for X and U:\",X.shape,usol.shape)\n",
        "print(\"Boundary shapes for the edges:\",left_X.shape,bottom_X.shape,top_X.shape)\n",
        "print(\"Available training data:\",X_train.shape,U_train.shape)\n",
        "print(\"Final training data:\",X_train_Nu.shape,U_train_Nu.shape)\n",
        "print(\"Total collocation points:\",X_train_Nf.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ySJY_09LzRXz",
        "outputId": "7cd91132-406e-4d44-8b1c-98c9b40ee847"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original shapes for X and U: (100, 256) (256, 100)\n",
            "Boundary shapes for the edges: (256, 2) (100, 2) (100, 2)\n",
            "Available training data: (456, 2) (456, 1)\n",
            "Final training data: (100, 2) (100, 1)\n",
            "Total collocation points: (10100, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train Neural Network"
      ],
      "metadata": {
        "id": "I82eH55ElVSq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "'Convert to tensor and send to GPU'\n",
        "X_train_Nf = torch.from_numpy(X_train_Nf).float().to(device)\n",
        "X_train_Nu = torch.from_numpy(X_train_Nu).float().to(device)\n",
        "U_train_Nu = torch.from_numpy(U_train_Nu).float().to(device)\n",
        "X_test = torch.from_numpy(X_test).float().to(device)\n",
        "u = torch.from_numpy(u_true).float().to(device)\n",
        "f_hat = torch.zeros(X_train_Nf.shape[0],1).to(device)\n",
        "\n",
        "PINN = FCN(layers)\n",
        "       \n",
        "PINN.to(device)\n",
        "\n",
        "'Neural Network Summary'\n",
        "print(PINN)\n",
        "\n",
        "params = list(PINN.parameters())\n",
        "\n",
        "'''Optimization'''\n",
        "\n",
        "'L-BFGS Optimizer'\n",
        "optimizer = torch.optim.LBFGS(PINN.parameters(), lr, \n",
        "                              max_iter = steps, \n",
        "                              max_eval = None, \n",
        "                              tolerance_grad = 1e-11, \n",
        "                              tolerance_change = 1e-11, \n",
        "                              history_size = 100, \n",
        "                              line_search_fn = 'strong_wolfe')\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "optimizer.step(PINN.closure)\n",
        "    \n",
        "    \n",
        "elapsed = time.time() - start_time                \n",
        "print('Training time: %.2f' % (elapsed))\n",
        "\n",
        "\n",
        "''' Model Accuracy ''' \n",
        "error_vec, u_pred = PINN.test()\n",
        "\n",
        "print('Test Error: %.5f'  % (error_vec))"
      ],
      "metadata": {
        "id": "8KZvgKcalOVV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b421072c-6908-4e45-a79a-531aead57cab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "FCN(\n",
            "  (activation): Tanh()\n",
            "  (loss_function): MSELoss()\n",
            "  (linears): ModuleList(\n",
            "    (0): Linear(in_features=2, out_features=20, bias=True)\n",
            "    (1): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (2): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (3): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (4): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (5): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (6): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (7): Linear(in_features=20, out_features=20, bias=True)\n",
            "    (8): Linear(in_features=20, out_features=1, bias=True)\n",
            "  )\n",
            ")\n",
            "tensor(0.1074, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.6189, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0546, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.4821, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0332, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.4155, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0186, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.2992, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0079, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.2298, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0039, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.1849, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0023, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.1780, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0014, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.1774, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0009, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.1354, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0005, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0820, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0004, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0238, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0003, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0277, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0002, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0306, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0002, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0282, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(0.0001, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0254, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(9.4598e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0246, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(7.6768e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0241, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(6.6554e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0258, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(5.6742e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0282, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(4.7770e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0252, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(4.1555e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0263, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(3.5798e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0275, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(3.2702e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0241, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(2.8299e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0251, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(2.6313e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0250, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(2.3924e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0261, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(2.1281e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0259, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.9680e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0277, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.8644e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0274, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.7449e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0287, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.6204e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0284, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.5414e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0279, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.4602e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0283, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.3798e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0286, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.2807e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0282, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.2029e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0277, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.1169e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0287, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(1.0572e-05, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0279, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(9.9495e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0282, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(9.4415e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0285, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(9.1038e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0285, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(8.7378e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0289, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(8.3930e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0292, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(8.0852e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0289, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(7.8370e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0285, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(7.5812e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0290, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(7.3443e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0288, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(7.0253e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0280, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(6.8118e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0281, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(6.5559e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0283, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(6.3332e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0289, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "tensor(6.1501e-06, device='cuda:0', grad_fn=<AddBackward0>) tensor(0.0289, device='cuda:0', grad_fn=<DivBackward0>)\n",
            "Training time: 99.94\n",
            "Test Error: 0.02899\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "solutionplot(u_pred,X_train_Nu.cpu().detach().numpy(),U_train_Nu)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 318
        },
        "id": "8yI5eSZP5zD6",
        "outputId": "fb8379ec-6512-49c2-9b66-bee5d970d580"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Plots"
      ],
      "metadata": {
        "id": "kpRh89zM8Te8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x1=X_test[:,0]\n",
        "t1=X_test[:,1]"
      ],
      "metadata": {
        "id": "otgA5_xXqb4S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arr_x1=x1.reshape(shape=X.shape).transpose(1,0).detach().cpu()\n",
        "arr_T1=t1.reshape(shape=X.shape).transpose(1,0).detach().cpu()\n",
        "arr_y1=u_pred\n",
        "arr_y_test=usol"
      ],
      "metadata": {
        "id": "90-ygJjca2c_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot3D_Matrix(arr_x1,arr_T1,torch.from_numpy(arr_y1))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "ituXQapsciqE",
        "outputId": "dfa1c570-b826-46f2-d04f-c2887ada71a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot3D(torch.from_numpy(x),torch.from_numpy(t),torch.from_numpy(usol)) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "xarXcLDdeF7X",
        "outputId": "7ed17df5-3e0c-4380-bc03-477036a1da8a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## References:\n"
      ],
      "metadata": {
        "id": "K_21EpoD1fZi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[1] Raissi, M., Perdikaris, P., & Karniadakis, G. E. (2017). Physics informed deep learning (part i): Data-driven solutions of nonlinear partial differential equations. arXiv preprint arXiv:1711.10561. http://arxiv.org/pdf/1711.10561v1\n",
        "\n",
        "[2] Lu, L., Meng, X., Mao, Z., & Karniadakis, G. E. (1907). DeepXDE: A deep learning library for solving differential equations,(2019). URL http://arxiv. org/abs/1907.04502. https://arxiv.org/abs/1907.04502\n",
        "\n",
        "[3] Rackauckas Chris, Introduction to Scientific Machine Learning through Physics-Informed Neural Networks. https://book.sciml.ai/notes/03/\n",
        "\n",
        "[4] Repository: Physics-Informed-Neural-Networks (PINNs).https://github.com/omniscientoctopus/Physics-Informed-Neural-Networks/tree/main/PyTorch/Burgers'%20Equation\n"
      ],
      "metadata": {
        "id": "SUFzJJ23ZR2O"
      }
    }
  ]
}
